2011-01-17 21:59:00
目录：
C++ 下 Function 对象的实现（上） C++ 下 Function 对象的实现（下）
上篇中，我们实现了一个支持 R () 型函数的 Function。补充说明一下，在我们对成员函数的支持中，我们是这样定义的：
1template <typename R, typename T>
2class MemberFunction0 : public FunctionBase0<R>
3{
4
5private:
6 R (T::*m_pMemFun)();
7 T *m_pObj;
8};
Loki 特意在著作中提醒我们，这里的 T 最好不要是函数类型，改为函数指针类型，如此该类的支持范围将扩大。如下：
1template <typename R, typename P, typename T>
2class MemberFunction0 : public FunctionBase0<R>
3{
4public:
5 R Invoke()
6 {
7 return (m_pObj->*m_pMemFun)();
8 }
9
10public:
11 MemberFunction0(P pObj, R (T::*pMemFun)())
12 : m_pObj(pObj), m_pMemFun(pMemFun)
13 {
14
15 }
16
17private:
18 R (T::*m_pMemFun)();
19 P m_pObj;
20};
于是，P 和 T 的关系不那么紧密了，P 不一定非要 T* 不可，也可以是诸如 SmartPtr 之类的玩意儿。原本只支持传入一个对象和该对象的成员函数的，现在变成传入一个具有指针概念的东东和一个成员函数，只要这个“指针”使用运算符 –> 去调用那个成员函数合乎语法即可。
接下来，我们来扩展这个 Function，以支持拥有数目在给定上限内的任意参数的函数。
我们先来手工写一下，看看如何支持带一个参数的函数。首先定义一个虚基类：
1template <typename R, typename T0>
2class FunctionBase1
3{
4public:
5 virtual R Invoke(T0) = 0;
6 virtual ~FunctionBase1() {}
7};
实现两个版本，分别支持非成员函数和成员函数：
1template <typename R, typename T0, typename T>
2class Function1 : public FunctionBase1<R, T0>
3{
4public:
5 R Invoke(T0 v0)
6 {
7 return m_Fun(v0);
8 }
9
10public:
11 Function1(const T &fun)
12 : m_Fun(fun)
13 {
14
15 }
16
17private:
18 T m_Fun;
19};
20
21template <typename R, typename P, typename T, typename T0>
22class MemberFunction1 : public FunctionBase1<R, T0>
23{
24public:
25 R Invoke(T0 v0)
26 {
27 return (m_pObj->*m_pMemFun)(v0);
28 }
29
30public:
31 MemberFunction1(P pObj, R (T::*pMemFun)(T0))
32 : m_pObj(pObj), m_pMemFun(pMemFun)
33 {
34
35 }
36
37private:
38 R (T::*m_pMemFun)(T0);
39 P m_pObj;
40};
41
42增加一个函数引用萃取的偏特化版本：
43
44template <typename RetType, typename T0>
45struct FunctionTraits<RetType (T0)>
46{
47 typedef RetType (&ParamType)(T0);
48};
49
50增加一个 Function 类的偏特化版本：
51
52template <typename R, typename T0>
53class Function<R (T0)>
54{
55public:
56 template <typename T>
57 Function(const T &fun)
58 : m_pFunBase(new Function1<R, T0, typename FunctionTraits<T>::ParamType>(fun))
59 {
60
61 }
62
63 template <typename P, typename T>
64 Function(P pObj, R (T::*pMemFun)(T0))
65 : m_pFunBase(new MemberFunction1<R, P, T, T0>(pObj, pMemFun))
66 {
67
68 }
69
70 ~Function()
71 {
72 delete m_pFunBase;
73 }
74
75 R operator ()(T0 v0)
76 {
77 return m_pFunBase->Invoke(v0);
78 }
79
80private:
81 FunctionBase1<R, T0> *m_pFunBase;
82};
现在，我们可以跑一下测试代码了：
1Function<int (int)> f1(&intfun1);
2Function<int (int)> f1_(intfun1);
3Function<int (int)> f2(intfunctor1);
4Function<int (int)> f3(&test, &Test::intmem1);
5
6f1(1);
7f1_(1);
8f2(2);
9f3(3);
当然，void 函数也是支持的。
观察上面的这些代码，和我们在上一篇中的代码高度一致，不同的是那些模版参数、偏特化参数、函数调用参数等地方。
假如有这么一组宏： TYPENAME_DECLARE(n) 被定义为 typename T0, typename T1, …, typename Tn TYPENAME_LIST(n) 被定义为 T0, T1, …, Tn TYPENAME_VARIABLE(n) 被定义为 T0 v0, T1 v1, …, Tn vn VARIABLE_LIST(n) 被定义为 v0, v1, …, vn
那么我们可以使用一个 n 就写出支持所有具有参数的函数的 Function 了。我们抛弃掉上面的 1 系列的所有类，仅保持上篇留下来的代码，然后利用上面 4 个宏将所有数字尾巴去掉，于是代码变成：
1template <typename R, TYPENAME_DECLARE(n)>
2class FunctionBase_##n
3{
4public:
5 virtual R Invoke(TYPENAME_LIST(n)) = 0;
6 virtual ~FunctionBase_##n() {}
7};
8
9
10template <typename R, TYPENAME_DECLARE(n), typename T>
11class Function_##n : public FunctionBase_##n<R, TYPENAME_LIST(n)>
12{
13public:
14 R Invoke(TYPENAME_VARIABLE(n))
15 {
16 return m_Fun(VARIABLE_LIST(n));
17 }
18
19public:
20 Function_##n(const T &fun)
21 : m_Fun(fun)
22 {
23
24 }
25
26private:
27 T m_Fun;
28};
29
30template <typename R, typename P, typename T, TYPENAME_DECLARE(n)>
31class MemberFunction_##n : public FunctionBase_##n<R, TYPENAME_LIST(n)>
32{
33public:
34 R Invoke(TYPENAME_VARIABLE(n))
35 {
36 return (m_pObj->*m_pMemFun)(VARIABLE_LIST(n));
37 }
38
39public:
40 MemberFunction_##n(P pObj, R (T::*pMemFun)(TYPENAME_LIST(n)))
41 : m_pObj(pObj), m_pMemFun(pMemFun)
42 {
43
44 }
45
46private:
47 R (T::*m_pMemFun)(TYPENAME_LIST(n));
48 P m_pObj;
49};
50
51template <typename RetType, TYPENAME_DECLARE(n)>
52struct FunctionTraits<RetType (TYPENAME_LIST(n))>
53{
54 typedef RetType (&ParamType)(TYPENAME_LIST(n));
55};
56
57template <typename R, TYPENAME_DECLARE(n)>
58class Function<R (TYPENAME_LIST(n))>
59{
60public:
61 template <typename T>
62 Function(const T &fun)
63 : m_pFunBase(new Function_##n<R, TYPENAME_LIST(n), typename FunctionTraits<T>::ParamType>(fun))
64 {
65
66 }
67
68 template <typename P, typename T>
69 Function(P pObj, R (T::*pMemFun)(TYPENAME_LIST(n)))
70 : m_pFunBase(new MemberFunction_##n<R, P, T, TYPENAME_LIST(n)>(pObj, pMemFun))
71 {
72
73 }
74
75 ~Function()
76 {
77 delete m_pFunBase;
78 }
79
80 R operator ()(TYPENAME_VARIABLE(n))
81 {
82 return m_pFunBase->Invoke(VARIABLE_LIST(n));
83 }
84
85private:
86 FunctionBase_##n<R, TYPENAME_LIST(n)> *m_pFunBase;
87};
当然上面这样子的代码是没法跑的咯。如果我们将整段代码定义为一个宏 BODY(n)，然后用类似刚才四个宏的方式定义宏 FUNCTION_IMPLEMENT(n)，使得它的含义为 BODY(0), BODY(1), …, BODY(n)，所有工作就都完成了。最后只需要丢下一句 FUNCTION_IMPLEMENT(20)，就可以支持 0 到 21 个参数了。
最后归结为，如何使用宏搞出“T0, T1, …, Tn” 的形式。
暴力点，我们可以这样：
1#define T_0 T0
2#define T_1 T_0, T1
3#define T_2 T_1, T2
4#define T_3 T_2, T3
5#define T_4 T_3, T4
6#define T_5 T_4, T5
7#define T_6 T_5, T6
8#define T_7 T_6, T7
9#define T_8 T_7, T8
10#define T_9 T_8, T9
11
12#define T(n) T_##n
这样子，对于上面四个宏可以，但是对于最后的 X(n)，人工代码量还是太大了。嗯？X(n)？对，这个 X，必须在 _1、_2、_3 系列宏里面占据一个参数地位，这样才有那么一点点扩展性。考虑换成这样：
1#define REP_0(macro, n) macro(0)
2#define REP_1(macro, n) REP_0(macro, n), macro(1)
3#define REP_2(macro, n) REP_1(macro, n), macro(2)
4#define REP_3(macro, n) REP_2(macro, n), macro(3)
5#define REP_4(macro, n) REP_3(macro, n), macro(4)
6#define REP_5(macro, n) REP_4(macro, n), macro(5)
7#define REP_6(macro, n) REP_5(macro, n), macro(6)
8#define REP_7(macro, n) REP_6(macro, n), macro(7)
9#define REP_8(macro, n) REP_7(macro, n), macro(8)
10#define REP_9(macro, n) REP_8(macro, n), macro(9)
11
12#define REP(macro, n) REP_##n(macro, n)
然后：
1#define TYPENAME_LIST_PATTERN(n) T##n
2#define TYPENAME_LIST(n) REP(TYPENAME_LIST_PATTERN, n)
这个 TYPENAME_LIST 就是符合上文要求的宏。接下来如法炮制其余三个：
1#define TYPENAME_DECLARE_PATTERN(n) typename T##n
2#define TYPENAME_DECLARE(n) REP(TYPENAME_DECLARE_PATTERN, n)
3
4#define TYPENAME_VARIABLE_PATTERN(n) T##n v##n
5#define TYPENAME_VARIABLE(n) REP(TYPENAME_VARIABLE_PATTERN, n)
6
7#define VARIABLE_LIST_PATTERN(n) v##n
8#define VARIABLE_LIST(n) REP(VARIABLE_LIST_PATTERN, n)
最后，我们在 #define FUNCTION_IMPLEMENT(n) REP(BODY, n) 中还存在一点点问题。因为 BODY 中会含有 TYPENAME_DECLARE 之类的宏的使用，而 TYPENAME_DECLARE 正是使用 REP 定义的。这涉及到宏的递归展开，C++预处理器的规则是，遇到这样的情况就停止展开。比如，我们 定义 BODY(n) 为 TYPENAME_DECLARE(n)，于是 FUNCTION_IMPLEMENT(2) 会被展成：
REP(TYPENAME_DECLARE_PATTERN, 0), REP(TYPENAME_DECLARE_PATTERN, 1), REP(TYPENAME_DECLARE_PATTERN, 2)
上面的 REP 不会被继续展开了。
为此，一个不太聪明的办法就是，再定义一组 REP2。嗯，是个办法，就这么办吧。另外我们刚才的 REP 系列没有将分隔符作为参数，默认使用逗号，而最后一不的 FUNCTION_IMPLEMENT 的重复中是不能用逗号的。考虑提取出来作为参数。最后我们的所需要的宏系统是：
1#define NIL
2#define COMMA ,
3
4#define REP_0(macro, splitter, n) macro(0)
5#define REP_1(macro, splitter, n) REP_0(macro, splitter, n) splitter macro(1)
6#define REP_2(macro, splitter, n) REP_1(macro, splitter, n) splitter macro(2)
7#define REP_3(macro, splitter, n) REP_2(macro, splitter, n) splitter macro(3)
8#define REP_4(macro, splitter, n) REP_3(macro, splitter, n) splitter macro(4)
9#define REP_5(macro, splitter, n) REP_4(macro, splitter, n) splitter macro(5)
10#define REP_6(macro, splitter, n) REP_5(macro, splitter, n) splitter macro(6)
11#define REP_7(macro, splitter, n) REP_6(macro, splitter, n) splitter macro(7)
12#define REP_8(macro, splitter, n) REP_7(macro, splitter, n) splitter macro(8)
13#define REP_9(macro, splitter, n) REP_8(macro, splitter, n) splitter macro(9)
14
15#define REP(macro, splitter, n) REP_##n(macro, splitter, n)
16
17#define REP2_0(macro, splitter, n) macro(0)
18#define REP2_1(macro, splitter, n) REP2_0(macro, splitter, n) splitter macro(1)
19#define REP2_2(macro, splitter, n) REP2_1(macro, splitter, n) splitter macro(2)
20#define REP2_3(macro, splitter, n) REP2_2(macro, splitter, n) splitter macro(3)
21#define REP2_4(macro, splitter, n) REP2_3(macro, splitter, n) splitter macro(4)
22#define REP2_5(macro, splitter, n) REP2_4(macro, splitter, n) splitter macro(5)
23#define REP2_6(macro, splitter, n) REP2_5(macro, splitter, n) splitter macro(6)
24#define REP2_7(macro, splitter, n) REP2_6(macro, splitter, n) splitter macro(7)
25#define REP2_8(macro, splitter, n) REP2_7(macro, splitter, n) splitter macro(8)
26#define REP2_9(macro, splitter, n) REP2_8(macro, splitter, n) splitter macro(9)
27
28#define REP2(macro, splitter, n) REP2_##n(macro, splitter, n)
29
30#define TYPENAME_DECLARE_PATTERN(n) typename T##n
31#define TYPENAME_DECLARE(n) REP(TYPENAME_DECLARE_PATTERN, COMMA, n)
32
33#define TYPENAME_LIST_PATTERN(n) T##n
34#define TYPENAME_LIST(n) REP(TYPENAME_LIST_PATTERN, COMMA, n)
35
36#define TYPENAME_VARIABLE_PATTERN(n) T##n v##n
37#define TYPENAME_VARIABLE(n) REP(TYPENAME_VARIABLE_PATTERN, COMMA, n)
38
39#define VARIABLE_LIST_PATTERN(n) v##n
40#define VARIABLE_LIST(n) REP(VARIABLE_LIST_PATTERN, COMMA, n)
41
42#define FUNCTION_IMPLEMENT(n) REP2(BODY, NIL, n)
最后，定义一下 FUNCTION_IMPLEMENT(5)，就可以支持到 6 个参数了。为了支持更多参数，把上面的 REP 以及 REP2 系列多定义一点，比如到 50，那么 FUNCTION_IMPLEMENT 的括号中就可以填 50 以内的任意数了。考虑到宏展开对编译速度的影响，以及实际应用中函数参数的个数，定为 20 左右比较合适。
到这里，我们的Function已经实现了预期目标。接下来我本来想说说 TypeList 的。可是现在发现没有 TypeList，Function 跑的通；有了 TypeList，Function 也不能写的漂亮多少，虽说那些重复部分有一定的减少。Loki 的 Functor 的参数类型是一个返回值类型加上一个 TypeList，是由用户直接传入 TypeList 的，不用由散的类型组合出一个TypeList（但还是要从TypeList中萃取各个参数类型），因此用在他那里看上去美妙一点点。当然，Loki 也在 Functor 外头包了一层 Function，以支持函数签名作为模版参数的使用方式。有一点不算改观的改观是，用了 TypeList 以后，就不会再有 FunctionBase_1, FunctionBase_2 这样的玩意儿了，取而代之的是一个统一的 FunctionBase 外加许多偏特化版本，Function* 和 MemberFunction* 可以分别统一为一个，但是每一个里头都需要实现 N 个 Invoke。加上篇幅关系，我想这里就不说这个 TypeList 了。
代码清单太长了，就不贴了，有意者自然能凑起来。我目前在 xlLib 中的最终实现见 xlFunction.h。
关于宏，我不知道可以怎样改进。BOOST_PP_REPEAT 貌似可以调用自身？不知道如何实现的，求指教。另外@vczh貌似说“实现了一门可以自己递归自己和内置列表处理的另一个宏”，求分享呀求分享。
2010-01-18 补充：将最外层 Function 的构造函数中的 const T & 直接改为 T，并且抛弃 FunctionTraits，函数实体类型将在传递过程中直接退化为函数指针，这样就能特化出正确的 FunctionHandler。同时带来另一点影响：如果传入 Functor，字面上将多一次拷贝动作。抛开这一点微小的性能来讲，这比刚才的 FunctionTraints 要好得多了。
首发：http://www.cppblog.com/Streamlet/archive/2011/01/17/138693.html